Noro's TrendMA StrategyThe strategy uses 2 moving averages. Fast and slow. SMA or EMA - the user can select. Moving averages are needed to identify the direction of the trend.
Trend
If both moving averages are directed upwards, it 's uptrend.
If both moving averages are pointing down, it 's downtrend.
If the moving averages are directed in different directions, the trend has not changed.
Background
Lime color is uptrend.
Red color is downtrend.
By default, background display is disabled, but you can enable it in script settings.
Trading
If uptrend (lime background) - open long position (and close short position)
If downtrend (red background) - open short position (and close long position)
Reverse trading, no stop-loss and take-profit
Short positions can be removed and only long positions can be traded.
For
- crypto/USD (XBT/USD, ETH/USD, etc)
- timeframes: 1h, 4h, 1d
Cerca negli script per "the strat"
Hucklekiwi Pip - HLHB Trend-Catcher SystemThe strategy was authored by Hucklekiwi Pip back in 2015 and is still being updated today. She says that the system was designed to simply catch short-term forex trends. At its heart, the system is a simple EMA crossover strategy with a couple of other indicators used for confirming entries.
Strategy Rules
See her original post here:
www.babypips.com
Be sure to check out the updates and tweaks over the years!
HOW TO USE
For full information on how to use this strategy and how to correctly set the exit time, see this post:
backtest-rookies.com
Febres StrategyThe strategy consist in every time that price failed to break any of the EMAs, we need to wait for the right price action and make a buy or sell when it bounce from it to keep surfing on the trend (using the stochastic oscillator and the 5-13 EMAs cross as an additional confirmation).
When do we start looking for a change on the trend? When it repeats the blue tracer (high or low of the previous day) without breaking it and bouncing from it, there will be our signal to start looking for a change of direction on the trend.
Only applicable on 15 minute chart.
Sb_Rate_Of_Change_BB_Band_strategy Version 1.0The strategy couples the concept of rate of change along with the Bollinger bands.
Along with it LazyBear's RSI/MFI with Volatility Indicator is also taken to reduce the number of trades and improve efficiency.
Strategy (in Layman terms):
If in the past 10 candles RSI/MFI with Volatility Indicator has printed a red/green colour and the roc has gone above/below the Bollinger bands then the short/long order is placed respectively.
Message if you think of any modifications/ enhancements/ any opportunities. :)
Donations/Tips... :) -
BTC: 1BjswGcRR6c23pka7qh5t5k56j46cuyyy2
ETH: 0x64fed71c9d6c931639c7ba4671aeb6b05e6b3781
LTC: LKT2ykQ8QSzzfTDB6Tnsf12xwYPjgq95h4
SB_Compliment_RSI StrategyThe strategy modifies the original rsi strategy with the addition of compliment si (i.e. 100-rsi).
Strategy Idea: Previous rsi high and low value is recorded when the rsi crosses overBought(70) and OverSold(30) values.
Now when the rsi crosses above the overSold range, the rsi is matched with the compliment of previous high rsi value. If the compliment i.e.(100-prev_rsi_high) is less than or equal to rsi then long position is taken.
For short position, when the rsi crosses below the overBought range, the rsi is matched with the compliment of previous low rsi value. If compliment i.e.(100-prev_rsi_low) is greater than or equal to rsi.
Below s the code for the indicator present in the chart.
//@version=3
study(title="SB_Compliment_Relative Strength Index", shorttitle="RSI")
src = close, len = input(14, minval=1, title="Length")
up = rma(max(change(src), 0), len)
down = rma(-min(change(src), 0), len)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
plot(rsi, color=purple)
plot(100-rsi, color=orange)
band1 = hline(70)
band0 = hline(30)
fill(band1, band0, color=purple, transp=90)
The code also has switch code also which means it will enter the overBrought or overSold block one after the other.
Future modifications: Currently the value of rsi tracked is the one in which it crosses the overSold or OverBought range and not the highest/lowest value when the value is above/below OverBought/OverSold range.
Comment the perfect combination of indicators for it and will try to incorporate those indicators into it in the next version.
Message if you think of any modifications/ enhancements/ any opportunities. :)
Donations/Tips... :) -
BTC: 1BjswGcRR6c23pka7qh5t5k56j46cuyyy2
ETH: 0x64fed71c9d6c931639c7ba4671aeb6b05e6b3781
LTC: LKT2ykQ8QSzzfTDB6Tnsf12xwYPjgq95h4
SB_Elder Impulse SystemThe strategy is based on LazyBear's Elder Impulse System
Strategy(in layman terms):
Long: When the green bar in the Elder Impulse System's indicator shows up
Short: When the red bar in the Elder Impulse System's indicator shows up
Close trade/Profit booking: When the blue bar in the Elder Impulse System's indicator shows up
Original Idea:
Message in the script if you think of any modifications/ enhancements.
Donations/Tips... :) -
BTC: 1BjswGcRR6c23pka7qh5t5k56j46cuyyy2
ETH: 0x64fed71c9d6c931639c7ba4671aeb6b05e6b3781
LTC: LKT2ykQ8QSzzfTDB6Tnsf12xwYPjgq95h4
Rainbow StrategyThe strategy is based on the following idea:
www.youtube.com
Not a fan of this but no script was present to show this idea's performance.
Best suitable for the 1-minute chart. You can change the ema values as per your needs.
For Tips to continue :) -
BTC: 1BjswGcRR6c23pka7qh5t5k56j46cuyyy2
ETH: 0x64fed71c9d6c931639c7ba4671aeb6b05e6b3781
LTC: LKT2ykQ8QSzzfTDB6Tnsf12xwYPjgq95h4
SB_CM_RSI_2_Strategy_Version 1.0The strategy is based on the indicator posted by @ChrisMoody "CM RSI-2 Strategy Lower Indicator" which is based on "Larry Connors RSI-2 Strategy - Lower RSI"
In this strategy the longs are placed when a green color is encountered in the rsi and short when red color is encountered in the rsi.
Although the profits can be booked at different interval.
Just message in the script if you have any different idea regarding this indicator.
For the original indicator you can refer to :
For Tips to continue :) :
BTC: 1BjswGcRR6c23pka7qh5t5k56j46cuyyy2
ETH: 0x64fed71c9d6c931639c7ba4671aeb6b05e6b3781
LTC: LKT2ykQ8QSzzfTDB6Tnsf12xwYPjgq95h4
Free Strategy #01 (ES / SPY)The strategy was designed to be traded based on daily data on the ES and SPY--the strategy was originally developed on NinjaTrader using approximately 50% out of sample data with a slippage of 1 tick on the ES. This is our first strategy that we converted from NinjaTrader to TradingView, so if you see any issues with our conversion, please let us know as we are still learning TradingView Pine Script.
Alerts v6The strategy includes:
✅ EMA-based trend direction (fast vs slow)
✅ RSI filtering for overbought/oversold control
✅ ADX confirmation for strong trend validation
✅ Pullback & BOS detection for precision entries
✅ Per-bar change logic for adaptive entry timing
✅ Session/day gating to control trading hours
✅ JSON alert integration for AI trading bots or webhooks
This script is Pine Script v6 compatible and optimized for automated alert-based trading setups such as AI trading bots, webhook systems, and VPS-linked executions.
Recommended Timeframes: 5m, 15m, 30m
Markets: XAUUSD, FX pairs, indices, and metals
CE+ZLSMA RovTrading StrateryThe strategy is optimized for scalping in small timeframes like M15 and M30, as well as M5.
It combines two indicators: CE and ZLSMA.
Try it now!
dabilThe strategy is probably to go short or long with the trend depending on the case, but if all time units 1 minute then 3 minutes then 5 minutes then 15 minutes then 1 hour all show the same direction, but first the 1 hour must be bullish in which the 1 hour candle closes above the previous one, for example if the trend is bearish then the market wants to change direction, then a 1 hour bullish close must then be followed by a 1 hour bearish close below the bullish candle, then another bullish candle must shoot above the previous bullish candle, then 15 minutes also shoot above the previous 15 bullish candles, then 1 and 2...3.5. Then I can rise with the market by only covering the last 15 bullish candles with my stop loss, if my SL is 50 pips then I want 100 pips and then I'm out.
I11L Long Put/Call Ratio InversionThe Strategy uses the Put/Call Options Ratio Inversaion as a Signal and Implements simple Money Management rules.
It is adjusted for the NDX and for the SPX in the 30min Range.
The Oscilation has to be finetuned to reflect the correct Reversal point.
A good indicator of the correct Reversal Point is a solid range of good backtesting results..
The strategy example. Close position by timeoutThis is an example how to close open entries by timeout for educational purpose.
Trend Following or Mean RevertingThe strategy checks nature of the instruments. It Buys if the close is greater than yesterday's high, reverse the position if the close is lower than yesterday's low and repeat the process.
1. If it is trend following then the equity curve will be in uptrend
2. If it is mean reverting then the equity curve will be downtrend
Thanks to Rayner Teo.
Bollinger and Tendencies (Bollinger e Tendências )The strategy consists of buying when the price breaks up (crossover) the bottom line of the Bollinger and selling when the price breaks down (crossunder) to your top line.
The chart still shows trends clearly, with the fill between the exponential average and the closing value of the canlestick, green at high, red at low (this part of the script is based on the code: "Pivot Daily Price Color" by Rimko).
It also places notes on the high and low candlesticks (based on the code: "Candlesticks Pattern Identified" by Repo32).
It is recommended to use it in conjunction with the "IFR and Storage" script (also available to me), and some volume script.
A estratégia consiste em comprar quando o preço rompe para cima (crossover) a linha inferior do Bollinger e vender quando o preço rompe para baixo (crossunder) a sua linha superior.
O gráfico ainda mostra as tendências de forma clara, com o preenchimento entre a média exponencial e o valor de fechamento do canlestick, verde em alta, vermelho em baixa (essa parte do script é baseada no código: "Pivot Daily Price Color" do usuário: Rimko).
Também, coloca apontamentos nos candlesticks de alta e de baixa (baseado no código: "Candlesticks Pattern Identified" do usuário Repo32).
Recomenda-se a utilização em conjunto com o script "IFR e Estocagem" (também por mim disponibilizado), e algum script de volume.
SB_Volume_oscillator_Prev_high_lowThe strategy is a take on traditional volume oscillator.
In Layman terms:
The script places an order when the oscillator crosses the zero mark in the volume oscillator.
If the previous high is greater than the absolute value of previous low then a long order is placed
And if the absolute previous low is greater than the previous high then a shrt order is placed.
Last script (bandwidth focus on other monetary works. If you have any opportunities ping me)
Message if you think of any modifications/ enhancements/ any opportunities. :)
Donations/Tips... :) -
BTC: 1BjswGcRR6c23pka7qh5t5k56j46cuyyy2
ETH: 0x64fed71c9d6c931639c7ba4671aeb6b05e6b3781
LTC: LKT2ykQ8QSzzfTDB6Tnsf12xwYPjgq95h4
TRADINGLibrary "TRADING"
This library is a client script for making a webhook signal formatted string to PoABOT server.
entry_message(password, percent, leverage, margin_mode, kis_number)
Create a entry message for POABOT
Parameters:
password (string) : (string) The password of your bot.
percent (float) : (float) The percent for entry based on your wallet balance.
leverage (int) : (int) The leverage of entry. If not set, your levereage doesn't change.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account. Default 1
Returns: (string) A json formatted string for webhook message.
order_message(password, percent, leverage, margin_mode, kis_number)
Create a order message for POABOT
Parameters:
password (string) : (string) The password of your bot.
percent (float) : (float) The percent for entry based on your wallet balance.
leverage (int) : (int) The leverage of entry. If not set, your levereage doesn't change.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account. Default 1
Returns: (string) A json formatted string for webhook message.
close_message(password, percent, margin_mode, kis_number)
Create a close message for POABOT
Parameters:
password (string) : (string) The password of your bot.
percent (float) : (float) The percent for close based on your wallet balance.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account. Default 1
Returns: (string) A json formatted string for webhook message.
exit_message(password, percent, margin_mode, kis_number)
Create a exit message for POABOT
Parameters:
password (string) : (string) The password of your bot.
percent (float) : (float) The percent for exit based on your wallet balance.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account. Default 1
Returns: (string) A json formatted string for webhook message.
manual_message(password, exchange, base, quote, side, qty, price, percent, leverage, margin_mode, kis_number, order_name)
Create a manual message for POABOT
Parameters:
password (string) : (string) The password of your bot.
exchange (string) : (string) The exchange
base (string) : (string) The base
quote (string) : (string) The quote of order message
side (string) : (string) The side of order messsage
qty (float) : (float) The qty of order message
price (float) : (float) The price of order message
percent (float) : (float) The percent for order based on your wallet balance.
leverage (int) : (int) The leverage of entry. If not set, your levereage doesn't change.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account.
order_name (string) : (string) The name of order message
Returns: (string) A json formatted string for webhook message.
in_trade(start_time, end_time, hide_trade_line)
Create a trade start line
Parameters:
start_time (int) : (int) The start of time.
end_time (int) : (int) The end of time.
hide_trade_line (bool) : (bool) if true, hide trade line. Default false.
Returns: (bool) Get bool for trade based on time range.
real_qty(qty, precision, leverage, contract_size, default_qty_type, default_qty_value)
Get exchange specific real qty
Parameters:
qty (float) : (float) qty
precision (float) : (float) precision
leverage (int) : (int) leverage
contract_size (float) : (float) contract_size
default_qty_type (string)
default_qty_value (float)
Returns: (float) exchange specific qty.
method set(this, password, start_time, end_time, leverage, initial_capital, default_qty_type, default_qty_value, margin_mode, contract_size, kis_number, entry_percent, close_percent, exit_percent, fixed_qty, fixed_cash, real, auto_alert_message, hide_trade_line)
Set bot object.
Namespace types: bot
Parameters:
this (bot)
password (string) : (string) password for poabot.
start_time (int) : (int) start_time timestamp.
end_time (int) : (int) end_time timestamp.
leverage (int) : (int) leverage.
initial_capital (float)
default_qty_type (string)
default_qty_value (float)
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
contract_size (float)
kis_number (int) : (int) kis_number for poabot.
entry_percent (float) : (float) entry_percent for poabot.
close_percent (float) : (float) close_percent for poabot.
exit_percent (float) : (float) exit_percent for poabot.
fixed_qty (float) : (float) fixed qty.
fixed_cash (float) : (float) fixed cash.
real (bool) : (bool) convert qty for exchange specific.
auto_alert_message (bool) : (bool) convert alert_message for exchange specific.
hide_trade_line (bool) : (bool) if true, Hide trade line. Default false.
Returns: (void)
method print(this, message)
Print message using log table.
Namespace types: bot
Parameters:
this (bot)
message (string)
Returns: (void)
method start_trade(this)
start trade using start_time and end_time
Namespace types: bot
Parameters:
this (bot)
Returns: (void)
method entry(this, id, direction, qty, limit, stop, oca_name, oca_type, comment, alert_message, when)
It is a command to enter market position. If an order with the same ID is already pending, it is possible to modify the order. If there is no order with the specified ID, a new order is placed. To deactivate an entry order, the command strategy.cancel or strategy.cancel_all should be used. In comparison to the function strategy.order, the function strategy.entry is affected by pyramiding and it can reverse market position correctly. If both 'limit' and 'stop' parameters are 'NaN', the order type is market order.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to cancel or modify an order by referencing its identifier.
direction (string) : (string) A required parameter. Market position direction: 'strategy.long' is for long, 'strategy.short' is for short.
qty (float) : (float) An optional parameter. Number of contracts/shares/lots/units to trade. The default value is 'NaN'.
limit (float) : (float) An optional parameter. Limit price of the order. If it is specified, the order type is either 'limit', or 'stop-limit'. 'NaN' should be specified for any other order type.
stop (float) : (float) An optional parameter. Stop price of the order. If it is specified, the order type is either 'stop', or 'stop-limit'. 'NaN' should be specified for any other order type.
oca_name (string) : (string) An optional parameter. Name of the OCA group the order belongs to. If the order should not belong to any particular OCA group, there should be an empty string.
oca_type (string) : (string) An optional parameter. Type of the OCA group. The allowed values are: "strategy.oca.none" - the order should not belong to any particular OCA group; "strategy.oca.cancel" - the order should belong to an OCA group, where as soon as an order is filled, all other orders of the same group are cancelled; "strategy.oca.reduce" - the order should belong to an OCA group, where if X number of contracts of an order is filled, number of contracts for each other order of the same OCA group is decreased by X.
comment (string) : (string) An optional parameter. Additional notes on the order.
alert_message (string) : (string) An optional parameter which replaces the {{strategy.order.alert_message}} placeholder when it is used in the "Create Alert" dialog box's "Message" field.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method order(this, id, direction, qty, limit, stop, oca_name, oca_type, comment, alert_message, when)
It is a command to place order. If an order with the same ID is already pending, it is possible to modify the order. If there is no order with the specified ID, a new order is placed. To deactivate order, the command strategy.cancel or strategy.cancel_all should be used. In comparison to the function strategy.entry, the function strategy.order is not affected by pyramiding. If both 'limit' and 'stop' parameters are 'NaN', the order type is market order.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to cancel or modify an order by referencing its identifier.
direction (string) : (string) A required parameter. Market position direction: 'strategy.long' is for long, 'strategy.short' is for short.
qty (float) : (float) An optional parameter. Number of contracts/shares/lots/units to trade. The default value is 'NaN'.
limit (float) : (float) An optional parameter. Limit price of the order. If it is specified, the order type is either 'limit', or 'stop-limit'. 'NaN' should be specified for any other order type.
stop (float) : (float) An optional parameter. Stop price of the order. If it is specified, the order type is either 'stop', or 'stop-limit'. 'NaN' should be specified for any other order type.
oca_name (string) : (string) An optional parameter. Name of the OCA group the order belongs to. If the order should not belong to any particular OCA group, there should be an empty string.
oca_type (string) : (string) An optional parameter. Type of the OCA group. The allowed values are: "strategy.oca.none" - the order should not belong to any particular OCA group; "strategy.oca.cancel" - the order should belong to an OCA group, where as soon as an order is filled, all other orders of the same group are cancelled; "strategy.oca.reduce" - the order should belong to an OCA group, where if X number of contracts of an order is filled, number of contracts for each other order of the same OCA group is decreased by X.
comment (string) : (string) An optional parameter. Additional notes on the order.
alert_message (string) : (string) An optional parameter which replaces the {{strategy.order.alert_message}} placeholder when it is used in the "Create Alert" dialog box's "Message" field.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method close_all(this, comment, alert_message, immediately, when)
Exits the current market position, making it flat.
Namespace types: bot
Parameters:
this (bot)
comment (string) : (string) An optional parameter. Additional notes on the order.
alert_message (string) : (string) An optional parameter which replaces the {{strategy.order.alert_message}} placeholder when it is used in the "Create Alert" dialog box's "Message" field.
immediately (bool) : (bool) An optional parameter. If true, the closing order will be executed on the tick where it has been placed, ignoring the strategy parameters that restrict the order execution to the open of the next bar. The default is false.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method cancel(this, id, when)
It is a command to cancel/deactivate pending orders by referencing their names, which were generated by the functions: strategy.order, strategy.entry and strategy.exit.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to cancel an order by referencing its identifier.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method cancel_all(this, when)
It is a command to cancel/deactivate all pending orders, which were generated by the functions: strategy.order, strategy.entry and strategy.exit.
Namespace types: bot
Parameters:
this (bot)
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method close(this, id, comment, qty, qty_percent, alert_message, immediately, when)
It is a command to exit from the entry with the specified ID. If there were multiple entry orders with the same ID, all of them are exited at once. If there are no open entries with the specified ID by the moment the command is triggered, the command will not come into effect. The command uses market order. Every entry is closed by a separate market order.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to close an order by referencing its identifier.
comment (string) : (string) An optional parameter. Additional notes on the order.
qty (float) : (float) An optional parameter. Number of contracts/shares/lots/units to exit a trade with. The default value is 'NaN'.
qty_percent (float) : (float) Defines the percentage (0-100) of the position to close. Its priority is lower than that of the 'qty' parameter. Optional. The default is 100.
alert_message (string) : (string) An optional parameter which replaces the {{strategy.order.alert_message}} placeholder when it is used in the "Create Alert" dialog box's "Message" field.
immediately (bool) : (bool) An optional parameter. If true, the closing order will be executed on the tick where it has been placed, ignoring the strategy parameters that restrict the order execution to the open of the next bar. The default is false.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
ticks_to_price(ticks, from)
Converts ticks to a price offset from the supplied price or the average entry price.
Parameters:
ticks (float) : (float) Ticks to convert to a price.
from (float) : (float) A price that can be used to calculate from. Optional. The default value is `strategy.position_avg_price`.
Returns: (float) A price level that has a distance from the entry price equal to the specified number of ticks.
method exit(this, id, from_entry, qty, qty_percent, profit, limit, loss, stop, trail_price, trail_points, trail_offset, oca_name, comment, comment_profit, comment_loss, comment_trailing, alert_message, alert_profit, alert_loss, alert_trailing, when)
It is a command to exit either a specific entry, or whole market position. If an order with the same ID is already pending, it is possible to modify the order. If an entry order was not filled, but an exit order is generated, the exit order will wait till entry order is filled and then the exit order is placed. To deactivate an exit order, the command strategy.cancel or strategy.cancel_all should be used. If the function strategy.exit is called once, it exits a position only once. If you want to exit multiple times, the command strategy.exit should be called multiple times. If you use a stop loss and a trailing stop, their order type is 'stop', so only one of them is placed (the one that is supposed to be filled first). If all the following parameters 'profit', 'limit', 'loss', 'stop', 'trail_points', 'trail_offset' are 'NaN', the command will fail. To use market order to exit, the command strategy.close or strategy.close_all should be used.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to cancel or modify an order by referencing its identifier.
from_entry (string) : (string) An optional parameter. The identifier of a specific entry order to exit from it. To exit all entries an empty string should be used. The default values is empty string.
qty (float) : (float) An optional parameter. Number of contracts/shares/lots/units to exit a trade with. The default value is 'NaN'.
qty_percent (float) : (float) Defines the percentage of (0-100) the position to close. Its priority is lower than that of the 'qty' parameter. Optional. The default is 100.
profit (float) : (float) An optional parameter. Profit target (specified in ticks). If it is specified, a limit order is placed to exit market position when the specified amount of profit (in ticks) is reached. The default value is 'NaN'.
limit (float) : (float) An optional parameter. Profit target (requires a specific price). If it is specified, a limit order is placed to exit market position at the specified price (or better). Priority of the parameter 'limit' is higher than priority of the parameter 'profit' ('limit' is used instead of 'profit', if its value is not 'NaN'). The default value is 'NaN'.
loss (float) : (float) An optional parameter. Stop loss (specified in ticks). If it is specified, a stop order is placed to exit market position when the specified amount of loss (in ticks) is reached. The default value is 'NaN'.
stop (float) : (float) An optional parameter. Stop loss (requires a specific price). If it is specified, a stop order is placed to exit market position at the specified price (or worse). Priority of the parameter 'stop' is higher than priority of the parameter 'loss' ('stop' is used instead of 'loss', if its value is not 'NaN'). The default value is 'NaN'.
trail_price (float) : (float) An optional parameter. Trailing stop activation level (requires a specific price). If it is specified, a trailing stop order will be placed when the specified price level is reached. The offset (in ticks) to determine initial price of the trailing stop order is specified in the 'trail_offset' parameter: X ticks lower than activation level to exit long position; X ticks higher than activation level to exit short position. The default value is 'NaN'.
trail_points (float) : (float) An optional parameter. Trailing stop activation level (profit specified in ticks). If it is specified, a trailing stop order will be placed when the calculated price level (specified amount of profit) is reached. The offset (in ticks) to determine initial price of the trailing stop order is specified in the 'trail_offset' parameter: X ticks lower than activation level to exit long position; X ticks higher than activation level to exit short position. The default value is 'NaN'.
trail_offset (float) : (float) An optional parameter. Trailing stop price (specified in ticks). The offset in ticks to determine initial price of the trailing stop order: X ticks lower than 'trail_price' or 'trail_points' to exit long position; X ticks higher than 'trail_price' or 'trail_points' to exit short position. The default value is 'NaN'.
oca_name (string) : (string) An optional parameter. Name of the OCA group (oca_type = strategy.oca.reduce) the profit target, the stop loss / the trailing stop orders belong to. If the name is not specified, it will be generated automatically.
comment (string) : (string) Additional notes on the order. If specified, displays near the order marker on the chart. Optional. The default is na.
comment_profit (string) : (string) Additional notes on the order if the exit was triggered by crossing `profit` or `limit` specifically. If specified, supercedes the `comment` parameter and displays near the order marker on the chart. Optional. The default is na.
comment_loss (string) : (string) Additional notes on the order if the exit was triggered by crossing `stop` or `loss` specifically. If specified, supercedes the `comment` parameter and displays near the order marker on the chart. Optional. The default is na.
comment_trailing (string) : (string) Additional notes on the order if the exit was triggered by crossing `trail_offset` specifically. If specified, supercedes the `comment` parameter and displays near the order marker on the chart. Optional. The default is na.
alert_message (string) : (string) Text that will replace the '{{strategy.order.alert_message}}' placeholder when one is used in the "Message" field of the "Create Alert" dialog. Optional. The default is na.
alert_profit (string) : (string) Text that will replace the '{{strategy.order.alert_message}}' placeholder when one is used in the "Message" field of the "Create Alert" dialog. Only replaces the text if the exit was triggered by crossing `profit` or `limit` specifically. Optional. The default is na.
alert_loss (string) : (string) Text that will replace the '{{strategy.order.alert_message}}' placeholder when one is used in the "Message" field of the "Create Alert" dialog. Only replaces the text if the exit was triggered by crossing `stop` or `loss` specifically. Optional. The default is na.
alert_trailing (string) : (string) Text that will replace the '{{strategy.order.alert_message}}' placeholder when one is used in the "Message" field of the "Create Alert" dialog. Only replaces the text if the exit was triggered by crossing `trail_offset` specifically. Optional. The default is na.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
percent_to_ticks(percent, from)
Converts a percentage of the supplied price or the average entry price to ticks.
Parameters:
percent (float) : (float) The percentage of supplied price to convert to ticks. 50 is 50% of the entry price.
from (float) : (float) A price that can be used to calculate from. Optional. The default value is `strategy.position_avg_price`.
Returns: (float) A value in ticks.
percent_to_price(percent, from)
Converts a percentage of the supplied price or the average entry price to a price.
Parameters:
percent (float) : (float) The percentage of the supplied price to convert to price. 50 is 50% of the supplied price.
from (float) : (float) A price that can be used to calculate from. Optional. The default value is `strategy.position_avg_price`.
Returns: (float) A value in the symbol's quote currency (USD for BTCUSD).
bot
Fields:
password (series__string)
start_time (series__integer)
end_time (series__integer)
leverage (series__integer)
initial_capital (series__float)
default_qty_type (series__string)
default_qty_value (series__float)
margin_mode (series__string)
contract_size (series__float)
kis_number (series__integer)
entry_percent (series__float)
close_percent (series__float)
exit_percent (series__float)
log_table (series__table)
fixed_qty (series__float)
fixed_cash (series__float)
real (series__bool)
auto_alert_message (series__bool)
hide_trade_line (series__bool)
HYE Combo Market [Strategy] (Vwap Mean Reversion + Trend Hunter)In this strategy, I used a combination of trend hunter and vwap mean reversion strategies that I published before.
Trend Hunter Strategy:
Mean Reversion Vwap Strategy:
The results are quite impressive, especially for bitcoin.
While the hodl return for bitcoin was 13419%, the strategy's return in the same period was about 5 times (65000%) of this.
s3.tradingview.com
In this combo strategy, I made some changes to the original settings of the strategies used together and added some more new features.
Trend Hunter Strategy Settings: (Original / Combo)
- Slow Tenkansen Period : 9 / 9
- Slow Kijunsen Period : 26 / 13
- Fast Tenkansen Period : 5 / 3
- Fast Kijunsen Period : 13 / 7
- BB Length : 20 / 20
- BB Stdev : 2 / 2
- TSV Length : 13 / 20
- TSV Ema Length : 7 / 7
* I also added a "vidya moving average" to be used as a confirmation tool to open a long position. (Candle close must be above the vidya line.)
Vwap Mean Reversion Strategy Settings: (Original / Combo)
- Small Vwap : 2 / 8
- Big Vwap : 5 / 10
- Percent Below to Buy : 3 / 2
- RSI Period : 2 / 2
- RSI Ema Period : 5 / 5
- Maximum RSI Level for Buy : 30
* I also added a "mean vwap line" to be used for exits in this part of the strategy. In the original version, when small vwap crossovers big vwap, we close the position, but in this strategy we will wait for the close above the mean vwap.
TIPS AND WARNINGS
1-) The standard settings of this combo strategy is designed and tested with daily timeframe. For lower timeframes, you should change the strategy settings and find the best value for yourself.
2-) Only the mean vwap line is displayed on the graph. For a detailed view, you can delete the "//" marks from the plot codes in the strategy code.
3-) This is a strategy for educational and experimental purposes. It cannot be considered as investment advice. You should be careful and make your own risk assessment when opening real market trades using this strategy.
________________________________________________________
Bu stratejide, daha önce yayınladığım trend avcısı ve vwap ortalamaya geri dönüş stratejilerinin bir kombinasyonunu kullandım.
Sonuçlar özellikle bitcoin için oldukça etkileyici.
Bitcoin için hodl getirisi %13419 iken, stratejinin aynı dönemdeki getirisi bunun yaklaşık 5 katı (%65000) idi.
Bu kombo stratejide, birlikte kullanılan stratejilerin orijinal ayarlarında bazı değişiklikler yaptım ve bazı yeni özellikler ekledim.
Trend Avcısı Strateji Ayarları: (Orijinal / Combo)
- Yavaş Tenkansen Periyodu : 9 / 9
- Yavaş Kijunsen Periyodu : 26 / 13
- Hızlı Tenkansen Periyodu : 5 / 3
- Hızlı Kijunsen Periyodu : 13 / 7
- BB Uzunluğu : 20 / 20
- BB Standart Sapması : 2 / 2
- TSV Uzunluğu : 13 / 20
- TSV Ema Uzunluğu : 7 / 7
* Ayrıca long pozisyon açmak için onay aracı olarak kullanılmak üzere "vidya hareketli ortalama" ekledim. (Mum kapanışı vidya çizgisinin üzerinde olmalıdır.)
Vwap Ortalamaya Dönüş Stratejisi Ayarları: (Orijinal / Combo)
- Küçük Vwap : 2 / 8
- Büyük Vwap : 5 / 10
- Alış İçin Gerekli Fark Oranı : 3 / 2
- RSI Periyodu : 2 / 2
- RSI Ema Periyodu: 5 / 5
- Alış için gerekli maksimum RSI seviyesi : 30
* Stratejinin bu bölümünde pozisyondan çıkışlar için kullanılacak bir "ortalama vwap çizgisi" de ekledim. Orijinal versiyonda, küçük vwap, büyük vwap'ı yukarı kestiğinde pozisyonu kapatıyoruz, ancak bu stratejide, ortalama vwap'ın üzerindeki kapanışı bekleyeceğiz.
İPUÇLARI VE UYARILAR
1-) Bu birleşik stratejinin standart ayarları, günlük zaman dilimi ile tasarlanmış ve test edilmiştir. Daha düşük zaman dilimleri için strateji ayarlarını değiştirmeli ve kendiniz için en iyi değeri bulmalısınız.
2-) Grafikte sadece ortalama vwap çizgisi görüntülenir. Ayrıntılı bir görünüm için strateji kodundaki "plot" ile başlayan satırlarda grafikte görünmesini istediğiniz özelliğin önündeki "//" işaretlerini silebilirsiniz.
3-) Eğitim ve deneysel amaçlı bir stratejidir. Yatırım tavsiyesi olarak değerlendirilemez. Bu stratejiyi kullanarak gerçek piyasa işlem açarken dikkatli olmalı ve kendi risk değerlendirmenizi yapmalısınız.
Systematic Investment Tracker by Ceyhun Gonul### English Description
**Systematic Investment Tracker with Enhanced Features**
This script, titled **Systematic Investment Tracker with Enhanced Features**, is a TradingView tool designed to support systematic investments across different market conditions. It provides traders with two customizable investment strategies — **Continuous Buying** and **Declining Buying** — and includes advanced dynamic investment adjustment features for each.
#### Detailed Explanation of Script Features and Originality
1. **Two Investment Strategies**:
- **Continuous Buying**: This strategy performs purchases consistently at each interval, as set by the user, regardless of market price changes. It follows the principle of dollar-cost averaging, allowing users to build an investment position over time.
- **Declining Buying**: Unlike Continuous Buying, this strategy triggers purchases only when the asset's price has declined from the previous interval's closing price. This approach helps users capitalize on lower price points, potentially improving average costs during downward trends.
2. **Dynamic Investment Adjustment**:
- For both strategies, the script includes a **Dynamic Investment Adjustment** feature. If enabled, this feature increases the purchasing amount by 50% if the current price has fallen by a specific user-defined percentage relative to the previous price. This allows users to accumulate a larger position when the asset is declining, which may benefit long-term cost-averaging strategies.
3. **Customizable Time Frames**:
- Users can specify a **start and end date** for investment, allowing them to restrict or backtest strategies within a specific timeframe. This feature is valuable for evaluating strategy performance over specific market cycles or historical periods.
4. **Graphical Indicators and Labels**:
- The script provides graphical labels on the chart that display purchase points. These indicators help users visualize their investment entries based on the strategy selected.
- A summary **performance label** is also displayed, providing real-time updates on the total amount spent, accumulated quantity, average cost, portfolio value, and profit percentage for each strategy.
5. **Language Support**:
- The script includes English and Turkish language options. Users can toggle between these languages, allowing the summary label text and descriptions to be displayed in their preferred language.
6. **Performance Comparison Table**:
- An optional **Performance Comparison Table** is available, offering a side-by-side analysis of net profit, total investment, and profit percentage for both strategies. This comparison table helps users assess which strategy has yielded better returns, providing clarity on each approach's effectiveness under the chosen parameters.
#### How the Script Works and Its Uniqueness
This closed-source script brings together two established investment strategies in a single, dynamic tool. By integrating continuous and declining purchase strategies with advanced settings for dynamic investment adjustment, the script offers a powerful, flexible tool for both passive and active investors. The design of this script provides unique benefits:
- Enables automated, systematic investment tracking, allowing users to build positions gradually.
- Empowers users to leverage declines through dynamic adjustments to optimize average cost over time.
- Presents an easy-to-read performance label and table, enabling an efficient and transparent performance comparison for informed decision-making.
---
### Türkçe Açıklama
**Gelişmiş Özellikli Sistematik Yatırım Takipçisi**
**Gelişmiş Özellikli Sistematik Yatırım Takipçisi** adlı bu TradingView scripti, çeşitli piyasa koşullarında sistematik yatırım stratejilerini desteklemek üzere tasarlanmış bir araçtır. Script, kullanıcıya iki özelleştirilebilir yatırım stratejisi — **Sürekli Alım** ve **Düşen Alım** — ve her strateji için gelişmiş dinamik yatırım ayarlama seçenekleri sunar.
#### Script Özelliklerinin Detaylı Açıklaması ve Özgünlük
1. **İki Yatırım Stratejisi**:
- **Sürekli Alım**: Bu strateji, fiyat değişimlerine bakılmaksızın kullanıcının belirlediği her aralıkta sabit bir miktar yatırım yapar. Bu yaklaşım, uzun vadede pozisyonu kademeli olarak oluşturmak isteyenler için idealdir.
- **Düşen Alım**: Sürekli Alım’ın aksine, bu strateji yalnızca fiyat bir önceki aralığın kapanış fiyatına göre düştüğünde alım yapar. Bu yöntem, yatırımcıların daha düşük fiyatlardan alım yaparak ortalama maliyeti potansiyel olarak iyileştirmelerine yardımcı olur.
2. **Dinamik Yatırım Ayarlaması**:
- Her iki strateji için de **Dinamik Yatırım Ayarlaması** özelliği bulunmaktadır. Bu özellik aktif edildiğinde, mevcut fiyatın bir önceki fiyata göre kullanıcı tarafından belirlenen bir yüzde oranında düşmesi durumunda alım miktarını %50 artırır. Bu durum, uzun vadede maliyet ortalaması stratejilerine katkıda bulunur.
3. **Özelleştirilebilir Tarih Aralığı**:
- Kullanıcılar, yatırımı belirli bir tarih aralığında sınırlandırmak veya test etmek için bir **başlangıç ve bitiş tarihi** belirleyebilir. Bu özellik, strateji performansını geçmiş piyasa döngüleri veya belirli dönemlerde değerlendirmek için kullanışlıdır.
4. **Grafiksel İşaretleyiciler ve Etiketler**:
- Script, grafik üzerinde alım noktalarını gösteren işaretleyiciler sağlar. Bu görsel göstergeler, kullanıcıların seçilen stratejiye göre yatırım girişlerini görselleştirmesine yardımcı olur.
- Ayrıca, her strateji için harcanan toplam tutar, biriken miktar, ortalama maliyet, portföy değeri ve kâr yüzdesi gibi bilgileri gerçek zamanlı olarak gösteren bir **performans etiketi** sunar.
5. **Dil Desteği**:
- Script, İngilizce ve Türkçe dillerini desteklemektedir. Kullanıcılar, performans etiketi metninin ve açıklamalarının tercih ettikleri dilde görüntülenmesi için dil seçimini yapabilir.
6. **Performans Karşılaştırma Tablosu**:
- İsteğe bağlı olarak kullanılabilen bir **Performans Karşılaştırma Tablosu**, her iki strateji için net kâr, toplam yatırım ve kâr yüzdesi gibi bilgileri yan yana analiz eder. Bu tablo, kullanıcıların hangi stratejinin daha yüksek getiri sağladığını değerlendirmesine yardımcı olur.
#### Scriptin Çalışma Prensibi ve Özgünlüğü
Bu script, iki yatırım stratejisini gelişmiş bir araçta birleştirir. Sürekli ve düşen fiyatlara dayalı alım stratejilerini dinamik yatırım ayarlama özelliğiyle entegre ederek yatırımcılar için güçlü ve esnek bir çözüm sunar. Script’in tasarımı aşağıdaki benzersiz faydaları sağlamaktadır:
- Otomatik, sistematik yatırım takibi yaparak kullanıcıların pozisyonlarını kademeli olarak oluşturmalarına olanak tanır.
- Dinamik ayarlama ile düşüşlerden yararlanarak zaman içinde ortalama maliyeti optimize etme olanağı sağlar.
- Her iki stratejinin performansını basit ve anlaşılır bir şekilde karşılaştıran etiket ve tablo ile verimli bir performans değerlendirmesi sunar.
ApicodeLibrary "Apicode"
percentToTicks(percent, from)
Converts a percentage of the average entry price or a specified price to ticks when the
strategy has an open position.
Parameters:
percent (float) : (series int/float) The percentage of the `from` price to express in ticks, e.g.,
a value of 50 represents 50% (half) of the price.
from (float) : (series int/float) Optional. The price from which to calculate a percentage and convert
to ticks. The default is `strategy.position_avg_price`.
Returns: (float) The number of ticks within the specified percentage of the `from` price if
the strategy has an open position. Otherwise, it returns `na`.
percentToPrice(percent, from)
Calculates the price value that is a specific percentage distance away from the average
entry price or a specified price when the strategy has an open position.
Parameters:
percent (float) : (series int/float) The percentage of the `from` price to use as the distance. If the value
is positive, the calculated price is above the `from` price. If negative, the result is
below the `from` price. For example, a value of 10 calculates the price 10% higher than
the `from` price.
from (float) : (series int/float) Optional. The price from which to calculate a percentage distance.
The default is `strategy.position_avg_price`.
Returns: (float) The price value at the specified `percentage` distance away from the `from` price
if the strategy has an open position. Otherwise, it returns `na`.
percentToCurrency(price, percent)
Parameters:
price (float) : (series int/float) The price from which to calculate the percentage.
percent (float) : (series int/float) The percentage of the `price` to calculate.
Returns: (float) The amount of the symbol's currency represented by the percentage of the specified
`price`.
percentProfit(exitPrice)
Calculates the expected profit/loss of the open position if it were to close at the
specified `exitPrice`, expressed as a percentage of the average entry price.
NOTE: This function may not return precise values for positions with multiple open trades
because it only uses the average entry price.
Parameters:
exitPrice (float) : (series int/float) The position's hypothetical closing price.
Returns: (float) The expected profit percentage from exiting the position at the `exitPrice`. If
there is no open position, it returns `na`.
priceToTicks(price)
Converts a price value to ticks.
Parameters:
price (float) : (series int/float) The price to convert.
Returns: (float) The value of the `price`, expressed in ticks.
ticksToPrice(ticks, from)
Calculates the price value at the specified number of ticks away from the average entry
price or a specified price when the strategy has an open position.
Parameters:
ticks (float) : (series int/float) The number of ticks away from the `from` price. If the value is positive,
the calculated price is above the `from` price. If negative, the result is below the `from`
price.
from (float) : (series int/float) Optional. The price to evaluate the tick distance from. The default is
`strategy.position_avg_price`.
Returns: (float) The price value at the specified number of ticks away from the `from` price if
the strategy has an open position. Otherwise, it returns `na`.
ticksToCurrency(ticks)
Converts a specified number of ticks to an amount of the symbol's currency.
Parameters:
ticks (float) : (series int/float) The number of ticks to convert.
Returns: (float) The amount of the symbol's currency represented by the tick distance.
ticksToStopLevel(ticks)
Calculates a stop-loss level using a specified tick distance from the position's average
entry price. A script can plot the returned value and use it as the `stop` argument in a
`strategy.exit()` call.
Parameters:
ticks (float) : (series int/float) The number of ticks from the position's average entry price to the
stop-loss level. If the position is long, the value represents the number of ticks *below*
the average entry price. If short, it represents the number of ticks *above* the price.
Returns: (float) The calculated stop-loss value for the open position. If there is no open position,
it returns `na`.
ticksToTpLevel(ticks)
Calculates a take-profit level using a specified tick distance from the position's average
entry price. A script can plot the returned value and use it as the `limit` argument in a
`strategy.exit()` call.
Parameters:
ticks (float) : (series int/float) The number of ticks from the position's average entry price to the
take-profit level. If the position is long, the value represents the number of ticks *above*
the average entry price. If short, it represents the number of ticks *below* the price.
Returns: (float) The calculated take-profit value for the open position. If there is no open
position, it returns `na`.
calcPositionSizeByStopLossTicks(stopLossTicks, riskPercent)
Calculates the entry quantity required to risk a specified percentage of the strategy's
current equity at a tick-based stop-loss level.
Parameters:
stopLossTicks (float) : (series int/float) The number of ticks in the stop-loss distance.
riskPercent (float) : (series int/float) The percentage of the strategy's equity to risk if a trade moves
`stopLossTicks` away from the entry price in the unfavorable direction.
Returns: (int) The number of contracts/shares/lots/units to use as the entry quantity to risk the
specified percentage of equity at the stop-loss level.
calcPositionSizeByStopLossPercent(stopLossPercent, riskPercent, entryPrice)
Calculates the entry quantity required to risk a specified percentage of the strategy's
current equity at a percent-based stop-loss level.
Parameters:
stopLossPercent (float) : (series int/float) The percentage of the `entryPrice` to use as the stop-loss distance.
riskPercent (float) : (series int/float) The percentage of the strategy's equity to risk if a trade moves
`stopLossPercent` of the `entryPrice` in the unfavorable direction.
entryPrice (float) : (series int/float) Optional. The entry price to use in the calculation. The default is
`close`.
Returns: (int) The number of contracts/shares/lots/units to use as the entry quantity to risk the
specified percentage of equity at the stop-loss level.
exitPercent(id, lossPercent, profitPercent, qty, qtyPercent, comment, alertMessage)
A wrapper for the `strategy.exit()` function designed for creating stop-loss and
take-profit orders at percentage distances away from the position's average entry price.
NOTE: This function calls `strategy.exit()` without a `from_entry` ID, so it creates exit
orders for *every* entry in an open position until the position closes. Therefore, using
this function when the strategy has a pyramiding value greater than 1 can lead to
unexpected results. See the "Exits for multiple entries" section of our User Manual's
"Strategies" page to learn more about this behavior.
Parameters:
id (string) : (series string) Optional. The identifier of the stop-loss/take-profit orders, which
corresponds to an exit ID in the strategy's trades after an order fills. The default is
`"Exit"`.
lossPercent (float) : (series int/float) The percentage of the position's average entry price to use as the
stop-loss distance. The function does not create a stop-loss order if the value is `na`.
profitPercent (float) : (series int/float) The percentage of the position's average entry price to use as the
take-profit distance. The function does not create a take-profit order if the value is `na`.
qty (float) : (series int/float) Optional. The number of contracts/lots/shares/units to close when an
exit order fills. If specified, the call uses this value instead of `qtyPercent` to
determine the order size. The exit orders reserve this quantity from the position, meaning
other orders from `strategy.exit()` cannot close this portion until the strategy fills or
cancels those orders. The default is `na`, which means the order size depends on the
`qtyPercent` value.
qtyPercent (float) : (series int/float) Optional. A value between 0 and 100 representing the percentage of the
open trade quantity to close when an exit order fills. The exit orders reserve this
percentage from the open trades, meaning other calls to this command cannot close this
portion until the strategy fills or cancels those orders. The percentage calculation
depends on the total size of the applicable open trades without considering the reserved
amount from other `strategy.exit()` calls. The call ignores this parameter if the `qty`
value is not `na`. The default is 100.
comment (string) : (series string) Optional. Additional notes on the filled order. If the value is specified
and not an empty "string", the Strategy Tester and the chart show this text for the order
instead of the specified `id`. The default is `na`.
alertMessage (string) : (series string) Optional. Custom text for the alert that fires when an order fills. If the
value is specified and not an empty "string", and the "Message" field of the "Create Alert"
dialog box contains the `{{strategy.order.alert_message}}` placeholder, the alert message
replaces the placeholder with this text. The default is `na`.
Returns: (void) The function does not return a usable value.
closeAllAtEndOfSession(comment, alertMessage)
A wrapper for the `strategy.close_all()` function designed to close all open trades with a
market order when the last bar in the current day's session closes. It uses the command's
`immediately` parameter to exit all trades at the last bar's `close` instead of the `open`
of the next session's first bar.
Parameters:
comment (string) : (series string) Optional. Additional notes on the filled order. If the value is specified
and not an empty "string", the Strategy Tester and the chart show this text for the order
instead of the automatically generated exit identifier. The default is `na`.
alertMessage (string) : (series string) Optional. Custom text for the alert that fires when an order fills. If the
value is specified and not an empty "string", and the "Message" field of the "Create Alert"
dialog box contains the `{{strategy.order.alert_message}}` placeholder, the alert message
replaces the placeholder with this text. The default is `na`.
Returns: (void) The function does not return a usable value.
closeAtEndOfSession(entryId, comment, alertMessage)
A wrapper for the `strategy.close()` function designed to close specific open trades with a
market order when the last bar in the current day's session closes. It uses the command's
`immediately` parameter to exit the trades at the last bar's `close` instead of the `open`
of the next session's first bar.
Parameters:
entryId (string)
comment (string) : (series string) Optional. Additional notes on the filled order. If the value is specified
and not an empty "string", the Strategy Tester and the chart show this text for the order
instead of the automatically generated exit identifier. The default is `na`.
alertMessage (string) : (series string) Optional. Custom text for the alert that fires when an order fills. If the
value is specified and not an empty "string", and the "Message" field of the "Create Alert"
dialog box contains the `{{strategy.order.alert_message}}` placeholder, the alert message
replaces the placeholder with this text. The default is `na`.
Returns: (void) The function does not return a usable value.
sortinoRatio(interestRate, forceCalc)
Calculates the Sortino ratio of the strategy based on realized monthly returns.
Parameters:
interestRate (simple float) : (simple int/float) Optional. The *annual* "risk-free" return percentage to compare against
strategy returns. The default is 2, meaning it uses an annual benchmark of 2%.
forceCalc (bool) : (series bool) Optional. A value of `true` forces the function to calculate the ratio on the
current bar. If the value is `false`, the function calculates the ratio only on the latest
available bar for efficiency. The default is `false`.
Returns: (float) The Sortino ratio, which estimates the strategy's excess return per unit of
downside volatility.
sharpeRatio(interestRate, forceCalc)
Calculates the Sharpe ratio of the strategy based on realized monthly returns.
Parameters:
interestRate (simple float) : (simple int/float) Optional. The *annual* "risk-free" return percentage to compare against
strategy returns. The default is 2, meaning it uses an annual benchmark of 2%.
forceCalc (bool) : (series bool) Optional. A value of `true` forces the function to calculate the ratio on the
current bar. If the value is `false`, the function calculates the ratio only on the latest
available bar for efficiency. The default is `false`.
Returns: (float) The Sortino ratio, which estimates the strategy's excess return per unit of
total volatility.
Velocity And Acceleration with Strategy: Traders Magazine◙ OVERVIEW
Hi, Ivestors and Traders... This Indicator, the focus is Scott Cong's article in the Stocks & Commodities September issue, “VAcc: A Momentum Indicator Based On Velocity And Acceleration”. I have also added a trading strategy for you to benefit from this indicator. First of all, let's look at what the indicator offers us and what its logic is. First, let's focus on the logic of the strategy.
◙ CONCEPTS
Here is a new indicator based on some simple physics concepts that is easy to use, responsive and precise. Learn how to calculate and use it.
The field of physics gives us some important principles that are highly applicable to analyzing the markets. In this indicator, I will present a momentum indicator. Scott Cong developed based on the concepts of velocity and acceleration this indicator. Of the many characteristics of price that traders and analysts often study, rate and rate of change are useful ones. In other words, it’s helpful to know: How fast is price moving, and is it speeding up or slowing down? How is price changing from one period to the next? The indicator I’m introducing here is calculated using the current bar (C) and every bar of a lookback period from the current bar. He named the indicator the VAcc since it’s based on the average of velocity line (av) and acceleration line (Acc) over the lookback period. For longer periods, the VAcc behaves the same way as the MACD, only it’s simpler, more responsive, and more precise. Interestingly, for shorter periods, VAcc exhibits characteristics of an oscillator, such as the stochastics oscillator.
◙ CALCULATION
The calculation of VAcc involves the following steps:
1. Relatively weighted average where the nearer price has the largest influence.
weighted_avg (float src, int length) =>
float sum = 0.0
for _i = 1 to length
float diff = (src - src ) / _i
sum += diff
sum /= length
2. The Velocity Average is smoothed with an exponential moving average. Now it get:
VAcc (float src, int period, int smoothing) =>
float vel = ta.ema(weighted_avg(src, period), smoothing)
float acc = weighted_avg(vel, period)
3. Similarly, accelerations for each bar within the lookback period and scale factor are calculated as:
= VAcc(src, length1, length2)
av /= (length1 * scale_factor)
◙ STRATEGY
In fact, Scott probably preferred to use it in periods 9 and 26 because it was similar to Macd and used the ratio of 0.5. However, I preferred to use the 8 and 21 periods to provide signals closer to the stochastic oscillator in the short term and used the 0.382 ratio. The logic of the strategy is this
Long Strategy → acc(Acceleration Line) > 0.1 and av(Velocity Average Line) > 0.1(Long Factor)
Short strategy → acc(Acceleration Line) < -0.1 and av(Velocity Average Line) < -0.1(Long Factor)
Here, you can change the Short Factor and Long Factor as you wish and produce more meaningful results that are closer to your own strategy.
I hope you benefits...
◙ GENEL BAKIŞ
Merhaba Yatırımcılar ve Yatırımcılar... Bu Gösterge, Scott Cong'un Stocks & Emtia Eylül sayısındaki “VAcc: Hız ve İvmeye Dayalı Bir Momentum Göstergesi” başlıklı makalesine odaklanmaktadır. Bu göstergeden faydalanabilmeniz için bir ticaret stratejisi de ekledim. Öncelikle göstergenin bize neler sunduğuna ve mantığının ne olduğuna bakalım. Öncelikle stratejinin mantığına odaklanalım.
◙ KAVRAMLAR
İşte kullanımı kolay, duyarlı ve kesin bazı basit fizik kavramlarına dayanan yeni bir gösterge. Nasıl hesaplanacağını ve kullanılacağını öğrenin.
Fizik alanı bize piyasaları analiz etmede son derece uygulanabilir bazı önemli ilkeler verir. Bu göstergede bir momentum göstergesi sunacağım. Scott Cong bu göstergeyi hız ve ivme kavramlarına dayanarak geliştirdi. Yatırımcıların ve analistlerin sıklıkla incelediği fiyatın pek çok özelliği arasında değişim oranı ve oranı yararlı olanlardır. Başka bir deyişle şunu bilmek faydalı olacaktır: Fiyat ne kadar hızlı hareket ediyor ve hızlanıyor mu, yavaşlıyor mu? Fiyatlar bir dönemden diğerine nasıl değişiyor? Burada tanıtacağım gösterge, mevcut çubuk (C) ve mevcut çubuktan bir yeniden inceleme döneminin her çubuğu kullanılarak hesaplanır. Göstergeye, yeniden inceleme dönemi boyunca hız çizgisinin (av) ve ivme çizgisinin (Acc) ortalamasına dayandığı için VAcc adını verdi. Daha uzun süreler boyunca VACc, MACD ile aynı şekilde davranır, yalnızca daha basit, daha duyarlı ve daha hassastır. İlginç bir şekilde, daha kısa süreler için VAcc, stokastik osilatör gibi bir osilatörün özelliklerini sergiliyor.
◙ HESAPLAMA
VAcc'nin hesaplanması aşağıdaki adımları içerir:
1. Yakın zamandaki fiyatın en büyük etkiye sahip olduğu göreceli ağırlıklı ortalamayı hesaplatıyoruz.
weighted_avg (float src, int length) =>
float sum = 0.0
for _i = 1 to length
float diff = (src - src ) / _i
sum += diff
sum /= length
2. Hız Ortalamasına üstel hareketli ortalamayla düzleştirme uygulanır. Şimdi bu şekilde aşağıdaki kod ile bunu şöyle elde ediyoruz:
VAcc (float src, int period, int smoothing) =>
float vel = ta.ema(weighted_avg(src, period), smoothing)
float acc = weighted_avg(vel, period)
3. Benzer şekilde, yeniden inceleme süresi ve ölçek faktörü içindeki her bir çubuk için fiyattaki ivmelenler yada momentum şu şekilde hesaplanır:
= VAcc(src, length1, length2)
av /= (length1 * scale_factor)
◙ STRATEJİ
Aslında Scott muhtemelen Macd'e benzediği ve 0,5 oranını kullandığı için 9. ve 26. periyotlarda kullanmayı tercih etmişti. Ancak kısa vadede stokastik osilatöre daha yakın sinyaller sağlamak için 8 ve 21 periyotlarını kullanmayı tercih ettim ve 0,382 oranını kullandım. Stratejinin mantığı şu
Uzun Strateji → acc(İvme Çizgisi) > 0,1 ve av(Hız Ortalama Çizgisi) > 0,1(Uzun Faktör)
Kısa strateji → acc(İvme Çizgisi) < -0,1 ve av(Hız Ortalama Çizgisi) < -0,1(Uzun Faktör)
Burada Kısa Faktör ve Uzun Faktör' ü dilediğiniz gibi değiştirip, kendi stratejinize daha yakın, daha anlamlı sonuçlar üretebilirsiniz.
umarım faydasını görürsün...
